home *** CD-ROM | disk | FTP | other *** search
/ ShareWare OnLine 2 / ShareWare OnLine Volume 2 (CMS Software)(1993).iso / ham / cat990.zip / FT990.C < prev    next >
C/C++ Source or Header  |  1993-02-01  |  35KB  |  1,547 lines
  1. /******************************************************************************              
  2. *        FT990.C                                  * 
  3. *                                          * 
  4. * 1. Computer Aided Transceiver sytem for the Yaesu FT-990 (Primary)          * 
  5. *                                          * 
  6. * 2. Some of the main commands are identical for the FT-1000, FT-890          * 
  7. *                                          * 
  8. * This is just a template program to test the CAT interface              * 
  9. * on the FT-1000 ,FT-990, and FT-890                          * 
  10. *                                          * 
  11. * This source (FT990.C and FT990.H) is in the public domain              * 
  12. * and may be freely copied                              * 
  13. *                                          * 
  14. * I do request any enhancements made to the program be made              * 
  15. * available to the general ham community too, so that others              * 
  16. * can enjoy doing this as much as I did.                      * 
  17. *=============================================================================+
  18. * and my thanks to:                                  * 
  19. *             C. Karcher                              * 
  20. *                  Seattle WA                              * 
  21. *                  CSID 76406,536                          * 
  22. *                                          * 
  23. * for providing the serial communications utility.                  * 
  24. *        (RS232.C,RS232.H)                          * 
  25. *=============================================================================+ 
  26. *                                          * 
  27. * Any questions or ideas for ft990.c should be addressed to the              * 
  28. * author:                                      * 
  29. *                                          * 
  30. *    Robert Cartier                                  * 
  31. *    112 Fieldbrook Rd.                              * 
  32. *    Middletown, Ct. 06457                              * 
  33. *    (203)771-7027 (Days)                              * 
  34. *       (203)632-9055 (Evenings)                          * 
  35. *    Compuserve : (76424,176)                          * 
  36. *    Packet     : KD1JG @ W1NRG.CT.USA                      * 
  37. *                                          * 
  38. *    Source was compiled using Borland Turbo C++ 1.0                  * 
  39. *                                          * 
  40. *    Date        Version                              * 
  41. *    --------    -------                              * 
  42. *    12/11/92    1.10    Released to the public domain by* Author      * 
  43. *                                                                             *
  44. *     12/16/92    1.20    Completed the Read Meter, Read Flags and      *
  45. *                Read Status.                                  *
  46. *                                                                             *
  47. *    12/17/92    1.21    Added Memory status option              * 
  48. ******************************************************************************/
  49. #include <conio.h>                        
  50. #include <ctype.h>                        
  51. #include <dir.h>                        
  52. #include <stdio.h>                        
  53. #include <stdlib.h>
  54. #include <string.h>
  55. #include "ft990.h"
  56. #include "rs232.c"
  57.  
  58. #define OUT_BUFSIZE 16U  /* 16 bytes output  buffer to minimize scan ahead*/
  59. #define IN_BUFSIZE 2048U /* enough for read status */
  60.  
  61. #define ESC 0x1b
  62.  
  63. char *version = "1.21";
  64. char *date    = "12-17-92";
  65.  
  66. static char in_buf[IN_BUFSIZE];
  67. static char out_buf[OUT_BUFSIZE];
  68.  
  69. int Convert_to_BCD(char *);
  70.  
  71. void Press_Rtn(void);
  72. void Read_5_Bytes(void);
  73. void Flush_Inbuffer(void);
  74. void Toggle_Value(int);
  75. void ScanDir(void);
  76.  
  77. void Read_Status(void);
  78. void Send_To_Radio(void);
  79. void Set_Freq(void);
  80. void Set_Up(char *, char *);
  81. void Toggle_Split_Vfo(void);
  82. void Recall_Mem(void);
  83. void Vfo_Mem(void);
  84. void Lock_Dial(void);
  85. void Toggle_Vfo(void);
  86. void Copy_Vfo_Mem(void);
  87. void Up_Down_Freq(void);
  88. void Scan(void);
  89. void Clarifier(void);
  90. void Set_Modes(void);
  91. void Set_Pacing(void);
  92. void Ptt(void);
  93. void Status_Update(void);
  94. void Tuner_Toggle(void);
  95. void Start_Tuner(void);
  96. void Rpt_Shift_Offset(void);
  97. void Vfo_A_B(void);
  98. void Bandwidth(void);
  99. void Mem_Scan_Skip(void);
  100. int  Step_Freq(void);
  101. void Read_Meter(void);
  102. void Dim_Level(void);
  103. void Read_Flags(void);
  104. void Update_Radio(void);
  105. void Scan_File(void);
  106. void Get_Mode(int);
  107. void Get_Filter(char *,int);
  108. void Disp_Mem(void);
  109.  
  110. void main()
  111. {
  112.     char answer[3] = {'\0'};
  113.     clrscr();
  114.  
  115.     Set_Up(in_buf,out_buf);    /*    initialize I/O port */
  116.  
  117.     for(;;)    {
  118.        clrscr();
  119.      puts("                   ╔════════════════════════════════════╗");
  120.      puts("                   ║ Computer Aided Transceiver Control ║");
  121.      puts("                   ║             for the                ║");
  122.      puts("                   ║           YAESU FT-990             ║");
  123.      puts("                   ║         with support for           ║");
  124.      puts("                   ║           FT-1000/890              ║"); 
  125.      puts("                   ║              KD1JG                 ║");
  126.      puts("                   ╚════════════════════════════════════╝");
  127.      puts("                               ┌───────────┐");
  128.      puts("                               │ Main Menu │");
  129.      puts("                               └───────────┘\n");
  130.      puts("    1. Set New Frequency    2. Recall Memory        3. Copy VFO->M ");
  131.      puts("    4. Lock/Unlock Dial     5. Select VFO           6. Copy M->VFO");
  132.      puts("    7. Step UP/DOWN         8. SCAN                 9. Set Clarifier");
  133.      puts("   10. Split VFO           11. Select Mode         12. Set Pacing ");
  134.      puts("   13. Ptt                 14. Get Radio Status    15. Activate Tuner");
  135.      puts("   16. Start Tuner         17. Rptr Shift/Offset   18. Copy VFO A<->B");
  136.      puts("   19. Select Bandwidth    20. Memory Chan skip    21. Step OP freq");
  137.      puts("   22. Read Meter          23. Dim Level           24. Read Flags");
  138.      puts("   25. Display Memory      26. Update from file    27. Scan From File");
  139.      puts("");
  140.      puts("                           99. Exit");
  141.      gotoxy(1,1);
  142.      printf("Ver. %s",version);
  143.      gotoxy(72,1);
  144.      printf("%s",date);
  145.      fflush(stdin);
  146.      gotoxy(1,25);
  147.      printf("Choice »   ");
  148.      gets(answer);
  149.  
  150.      clrscr();
  151.  
  152.      switch(atoi(answer)) {
  153.           case 1:
  154.         Set_Freq();
  155.         break;
  156.        case 2:
  157.         Recall_Mem();
  158.         break;
  159.        case 3:
  160.         Vfo_Mem();
  161.         break;
  162.        case 4:
  163.         Lock_Dial();
  164.         break;
  165.        case 5:
  166.         Toggle_Vfo();
  167.         break;
  168.        case 6:
  169.         Copy_Vfo_Mem();
  170.         break;
  171.        case 7:
  172.         Up_Down_Freq();
  173.         break;
  174.        case 8:
  175.         Scan();
  176.         break;
  177.        case 9:
  178.         Clarifier();
  179.         break;
  180.        case 10:
  181.         Toggle_Split_Vfo();
  182.         break;
  183.        case 11:
  184.         Set_Modes();
  185.         break;
  186.        case 12:
  187.         Set_Pacing();
  188.         break;
  189.        case 13:
  190.         Ptt();
  191.         break;
  192.        case 14:
  193.         Status_Update();
  194.         break;
  195.        case 15:
  196.         Tuner_Toggle();
  197.         break;
  198.        case 16:
  199.         Start_Tuner();
  200.         break;
  201.        case 17:
  202.         Rpt_Shift_Offset();
  203.         break;
  204.        case 18:
  205.         Vfo_A_B();
  206.         break;
  207.        case 19:
  208.         Bandwidth();
  209.         break;
  210.        case 20:
  211.         Mem_Scan_Skip();
  212.         break;
  213.        case 21:
  214.         Step_Freq();
  215.         break;
  216.        case 22:
  217.         Read_Meter();
  218.         break;
  219.        case 23:
  220.         Dim_Level();
  221.         break;
  222.        case 24:
  223.         Read_Flags();
  224.         break;
  225.        case 25:
  226.         Disp_Mem();
  227.         break;
  228.        case 26:
  229.         Update_Radio();
  230.         break;
  231.        case 27:
  232.         Scan_File();
  233.         break;
  234.        case 99:
  235.         rs_close();
  236.         clrscr();
  237.         puts("Robert Cartier - KD1JG ");
  238.         puts("Packet: KD1JG @ W1NRG.CT");
  239.         puts("CIS:    76424,176");
  240.         sleep(2);
  241.         exit(0);
  242.      }
  243.     }
  244. }
  245. void Set_Freq(void)
  246. {
  247.     int    i,j;
  248.  
  249.     double real_freq = 0;
  250.     double freq_khz = 0;
  251.  
  252.     char freq_out[20];
  253.     char freq_str[20];
  254.  
  255.     send.cmd.opcode = SET_FREQ;        
  256. enter_frq:
  257.     printf("Enter New Frequency : ");
  258.     scanf("%lf",&real_freq);
  259.  
  260.     freq_khz = real_freq * 100000.0;
  261.  
  262.     if ((freq_khz > 2999999) || (freq_khz < 100)){
  263.         printf("out of range -- re-enter\n\a");
  264.         goto enter_frq;
  265.     }
  266.     printf("Real Freq in khz : %08.0f\n",freq_khz);
  267.  
  268.     sprintf(freq_str,"%08.0f",freq_khz);
  269.  
  270.     for(i = 0, j = 0; i < 8 ; i += 2,j++)    
  271.      send.cmd.data[j] = Convert_to_BCD(&freq_str[i]);
  272.  
  273.     Send_To_Radio();
  274. }
  275.  
  276. int Convert_to_BCD(char *tmp)
  277. {
  278.     int bcd;
  279.     char high[2];
  280.     char low[2];
  281.     
  282.     strncpy(high,&tmp[0],1);
  283.     high[1] = '\0';
  284.     strncpy(low,&tmp[1],1);
  285.     low[1] = '\0';
  286.  
  287.     bcd = atoi(low);
  288.  
  289.     bcd += (atoi(high) * 16);
  290.  
  291.     return(bcd);
  292. }
  293.  
  294. void Set_Up(char *in_buf,char *out_buf)
  295. {
  296.  
  297.   char port,parity,bits,stop;
  298.   char tmp[2];
  299.   long baud;
  300.  
  301.   *tmp = '\0';
  302.   while(*tmp < '1' || *tmp > '4') {
  303.     printf("Communications Port (1,2,3 or 4):");
  304.     gets(tmp);
  305.   }
  306.   port = *tmp;
  307.   baud = 4800L;
  308.   parity = 'N';
  309.   bits = '8';
  310.   stop = '2';
  311.  
  312.   /* initialize port */
  313.   if(rs_initport(port,baud,parity,bits,stop,IN_BUFSIZE,in_buf,OUT_BUFSIZE,out_buf)) {
  314.     printf("Failed to initialize port\n");
  315.     rs_close();
  316.     exit(1);
  317.   }
  318. }
  319.  
  320. void Send_To_Radio(void)
  321. { 
  322.     short i = COMMAND_SIZE; /* init to size of command */
  323.  
  324.     Flush_Inbuffer();       /* flush input buffer */
  325.  
  326.     /* send data to radio in reverse order */
  327.  
  328.     do {
  329.       rs_sndbyt(send.cmd_fill.fill[i-1]);
  330.       i--;
  331.     }while(i != 0);
  332.  
  333.     memset(&send,0x00,COMMAND_SIZE);
  334.  
  335.     return;
  336. }
  337. void Toggle_Split_Vfo(void)
  338. {
  339.     Toggle_Value(SPLIT);
  340. }
  341. void Recall_Mem(void)
  342. {
  343.     char ch_str[3];
  344.     char answer[2];
  345.  
  346.     short channel = 0;
  347.  
  348.     printf("Enter Channel to Recall : ");
  349.     scanf("%s",ch_str);
  350.     channel = atoi(ch_str);
  351.     if(channel > 90) {
  352.         printf("\aMust between 0 and 90");
  353.         return;
  354.     }
  355.     send.cmd.opcode  = RECALL_MEM;
  356.     send.cmd.data[0] = channel;
  357.     Send_To_Radio();
  358.  
  359.  
  360. }
  361. void Vfo_Mem(void)
  362. {
  363.     char ch_str[3];
  364.     char answer[2];
  365.  
  366.     short hide = 0;
  367.     short channel = 0;
  368.  
  369.     printf("Enter Channel to Store : ");
  370.     scanf("%s",ch_str);
  371.     channel = atoi(ch_str);
  372.     if((channel < 1) || (channel > 90)) {
  373.         printf("\aMust between 1 and 90");
  374.         return;
  375.     }
  376.     printf("Channel Selected : %s\n",ch_str);
  377.     printf("okay to update (y/n) : ");
  378.     scanf("%s",answer);
  379.  
  380.     if((toupper(*answer)) == 'Y') {
  381.         send.cmd.opcode  = VFO_M;
  382.         send.cmd.data[0] = channel;
  383.         send.cmd.data[1] = hide;
  384.  
  385.         Send_To_Radio();
  386.     }
  387.  
  388. }
  389. void Lock_Dial(void)
  390. {
  391.     Toggle_Value(LOCK_DIAL);
  392.  
  393. }
  394. void Toggle_Vfo(void)
  395. {
  396.     short flag = 1;
  397.     printf("Press any key to toggle <ESC> to exit\n ");
  398.     for(;;) {
  399.      if(kbhit()) {
  400.        if((getch()) == 0x1b)
  401.            break;
  402.        else {
  403.         gotoxy(35,12);
  404.         if( flag){
  405.             puts("VFO A");
  406.             send.cmd.data[0] = OFF;
  407.             flag = FALSE;
  408.         }
  409.         else{
  410.             puts("VFO B"); 
  411.             send.cmd.data[0] = ON;
  412.             flag = TRUE;
  413.         }
  414.                 send.cmd.opcode  = SELECT_VFO;
  415.         Send_To_Radio();
  416.        }
  417.      }
  418.     }
  419. }
  420. void Copy_Vfo_Mem(void)
  421. {
  422.     char ch_str[3];
  423.     char answer[2];
  424.  
  425.     short channel = 0;
  426.  
  427.     printf("Enter Channel to Copy : ");
  428.     scanf("%s",ch_str);
  429.     channel = atoi(ch_str);
  430.     if(channel > 90) {
  431.         printf("\aMust between 0 and 90");
  432.         return;
  433.     }
  434.     send.cmd.opcode  = M_VFO;
  435.     send.cmd.data[0] = channel;
  436.     Send_To_Radio();
  437.  
  438.  
  439. }
  440. void Up_Down_Freq(void)
  441. {
  442.     unsigned char c;
  443.     unsigned short step =0;
  444.     printf("Enter (1) for 1 MHZ or (0) 100 KHZ : ");
  445.     scanf("%d",&step);
  446.  
  447.     send.cmd.data[1] = step;
  448.  
  449.     puts("Enter <ESC> to quit or '+' or '-'");
  450.  
  451.     for(;;) {
  452.      if(kbhit()) {
  453.         gotoxy(35,12);
  454.        switch(getch()) {
  455.           case 0x1b : return;
  456.           case '+'  : 
  457.         puts("UP  ");
  458.         send.cmd.data[1] = step;
  459.         send.cmd.opcode  = UP;
  460.         break;              
  461.           case '-'  : 
  462.         puts("DOWN");
  463.         send.cmd.data[1] = step;
  464.         send.cmd.opcode  = DOWN;
  465.         break;              
  466.        }
  467.        Send_To_Radio();
  468.      }
  469.         }
  470.  
  471. }
  472. void Scan(void)
  473. {
  474.     int    c,i,j;
  475.     int    delay_time = 0;
  476.     int     step_counter = 0;
  477.  
  478.     double freq = 0;
  479.     double start_freq = 0;
  480.     double start_khz = 0;
  481.     double end_freq = 0;
  482.     double end_khz = 0;
  483.  
  484.     char freq_out[20];
  485.     char freq_str[20];
  486.  
  487.  
  488. start:
  489.     printf("Enter New Frequency in Mhz: ");
  490.     scanf("%lf",&start_freq);
  491.  
  492. end:
  493.     printf("Enter END Frequency in Mhz: ");
  494.     scanf("%lf",&end_freq);
  495.  
  496.  
  497.     start_khz = start_freq * 100000.0;
  498.     end_khz = end_freq * 100000.0;
  499.  
  500.     printf("Delay (tenths): ");
  501.     scanf("%d",&delay_time);
  502.  
  503.     if ((start_khz > 2999999) || (start_khz < 100)){
  504.         printf("out of range -- re-enter\n\a");
  505.         goto start;
  506.     }
  507.     if ((end_khz > 2999999) || (end_khz < 100)){
  508.         printf("out of range -- re-enter\n\a");
  509.         goto end;
  510.     }
  511.     sprintf(freq_str,"%08.0f",start_khz);
  512.  
  513.     for(i = 0, j = 0; i < 8 ; i += 2,j++)
  514.         send.cmd.data[j] = Convert_to_BCD(&freq_str[i]);
  515.  
  516.     send.cmd.opcode = SET_FREQ;        
  517.  
  518.     Send_To_Radio();
  519.  
  520.     Set_Modes();
  521.  
  522.     clrscr();
  523.  
  524.         gotoxy(20,20);
  525.     puts("Press any key to stop scanning");
  526.  
  527.     for(freq = start_khz; freq < end_khz + 1.0 ; freq++){
  528.  
  529.  
  530.       if (kbhit()){
  531.         step_counter = Step_Freq();
  532.         freq = freq + step_counter; 
  533.         gotoxy(20,20);
  534.         clreol();
  535.         printf("Press any key to continue scan or <ESC> to exit");
  536.  
  537.          while (!kbhit());
  538.         c = getch();
  539.         if (c == ESC)
  540.             break;
  541.  
  542.         gotoxy(20,20);
  543.         clreol();
  544.             gotoxy(20,20);
  545.         puts("Press any key to stop scanning");
  546.       }
  547.       delay(delay_time * 100); 
  548.       gotoxy(35,12);
  549.       printf("%2.5f",(freq) / 100000.00);
  550.  
  551.       send.cmd.opcode = STEP_FREQ;
  552.       Send_To_Radio();
  553.  
  554.     /* start over  */
  555.  
  556.       if (freq == end_khz  )
  557.       {
  558.  
  559.         sprintf(freq_str,"%08.0f",start_khz);
  560.       
  561.        for(i = 0, j = 0; i < 8 ; i += 2,j++)    
  562.         send.cmd.data[j] = Convert_to_BCD(&freq_str[i]);
  563.  
  564.        send.cmd.opcode = SET_FREQ;
  565.  
  566.        Send_To_Radio();
  567.  
  568.        freq = start_khz;
  569.  
  570.       }
  571.     }    
  572. }
  573.  
  574. void Clarifier(void)
  575. {
  576.     puts("Not completed sorry...");
  577.     sleep(5);    
  578. }
  579. void Set_Modes(void)
  580. {
  581.     char answer[3];    
  582.     int mode = 0;
  583.  
  584.     do{
  585.      clrscr();
  586.      fflush(stdin);
  587.      printf("Enter Mode\n\n");
  588.      printf("\t 0.  LSB\n");
  589.      printf("\t 1.  USB\n");
  590.      printf("\t 2.  CW 2.4k\n");
  591.      printf("\t 3.  CW 500\n");
  592.      printf("\t 4.  AM 6k\n");
  593.      printf("\t 5.  AM 2.4k\n");
  594.      printf("\t 6.  FM\n");
  595.      printf("\t 8.  RTTY (LSB) FT-990\n");
  596.      printf("\t 9.  RTTY (USB) FT-990\n");
  597.      printf("\t10.  PKT (LSB)  FT-990\n");
  598.      printf("\t11.  PKT (FM)   FT-990\n");
  599.      printf("\t12.  Exit\n");
  600.      printf("\nChoice : ");
  601.      gets(answer); 
  602.      mode = atoi(answer); 
  603.  
  604.      if(mode > 12) {
  605.         printf("\aMust between 0 and 11");
  606.         delay(2000);
  607.         continue;
  608.      }
  609.      send.cmd.opcode  = SET_MODE;
  610.      send.cmd.data[0] = mode;
  611.      Send_To_Radio();
  612.     }while(mode != 12);
  613.     
  614. }
  615. void Set_Pacing(void)
  616. {
  617.     unsigned short delay = 0;
  618.     unsigned char answer[2];
  619.  
  620.     printf("Enter Pacing delay in Milliseconds : ");
  621.     scanf("%d",&delay);
  622.  
  623.     if((delay > 255)) {
  624.         printf("\aMust between less than 255");
  625.         return;
  626.     }
  627.     printf("Pacing Delay : %d\n",delay);
  628.     printf("okay to set (y/n) : ");
  629.     scanf("%s",answer);
  630.  
  631.     if((toupper(*answer)) == 'Y') {
  632.      send.cmd.opcode  = PACING;
  633.      send.cmd.data[0] = delay;
  634.  
  635.      Send_To_Radio();
  636.     }
  637.     
  638. }
  639. void Ptt(void)
  640. {
  641.     Toggle_Value(PTT);
  642. }
  643. void Status_Update(void)
  644. {
  645.     double frequency = 0;
  646.  
  647.     clrscr();
  648.  
  649.     send.cmd.opcode  = UPDATE;
  650.  
  651.     Send_To_Radio();
  652.     
  653.     Read_Status();
  654.  
  655.     clrscr();
  656.  
  657.     gotoxy(1,2);
  658.     printf("Split       : %s",r_update.r_update_data.byte_1.bit_0 == 0 ? "Off":"On");
  659.  
  660.     gotoxy(1,3);
  661.     printf("VFO_B       : %s",r_update.r_update_data.byte_1.bit_1 == 0 ? "Transmit" : "Receive");
  662.  
  663.     gotoxy(1,4);
  664.     printf("Fast Tuning : %s",r_update.r_update_data.byte_1.bit_2 == 0 ? "Deactive" : "Active");
  665.  
  666.     gotoxy(1,5);
  667.     printf("Tuner       : %s",r_update.r_update_data.byte_3.bit_6 == 0 ? "Off" : "On");
  668.  
  669.     gotoxy(1,6);
  670.     printf("Transmision : %s",r_update.r_update_data.byte_1.bit_7 == 0 ? "None" : "In-progress");
  671.  
  672.     gotoxy(56,2);
  673.     printf("Scanning    : %s",r_update.r_update_data.byte_2.bit_2 == 0 ? "None" : "In-progress");
  674.  
  675.     gotoxy(56,3);
  676.     printf("Tuning Knob : %s",r_update.r_update_data.byte_2.bit_3 == 0 ? "Unlocked" : "Locked");
  677.  
  678.     gotoxy(56,4);
  679.     printf("M Tune      : %s",r_update.r_update_data.byte_2.bit_4 == 0 ? "Inactive" : "Active");
  680.  
  681.     gotoxy(56,5);
  682.     printf("Tuner       : %s",r_update.r_update_data.byte_1.bit_4 == 0 ? "Inactive" : "Tuning");
  683.  
  684.     gotoxy(56,6);
  685.     if(r_update.r_update_data.byte_2.bit_5 == TRUE)
  686.         printf("Operation   : VFO");
  687.     else if(r_update.r_update_data.byte_2.bit_6 == TRUE)
  688.         printf("Operation   : MEM");
  689.     else if(r_update.r_update_data.byte_2.bit_7 == TRUE)
  690.         printf("Operation   : GEN");
  691.     else
  692.         printf("Operation   : Unknown");
  693.  
  694.     
  695.     gotoxy(30,8);
  696.     printf("Memory Channel  :  ( %d ) ",
  697.             r_update.r_update_data.mem_ch  + 1 );
  698.  
  699. /********************************************************************/
  700.  
  701.     gotoxy(1,9);
  702.         printf("═══════════════════════════════════════════════════════════════════════════");
  703.     gotoxy(1,11);
  704.     printf("  Current status               VFO A  status              VFO B  status \n");
  705.     printf("  --------------               ---------------            --------------\n\n");
  706.  
  707.     gotoxy(1,13);
  708.     printf("Filter      :  %#04x",r_update.r_update_data.current.bpf);
  709.  
  710.     frequency = frequency + ((double)r_update.r_update_data.current.freq1 * 65536);
  711.     frequency = frequency + ((double)r_update.r_update_data.current.freq2 * 256);
  712.     frequency = frequency + (double)r_update.r_update_data.current.freq3;
  713.  
  714.     gotoxy(1,14);
  715.     printf("Frequency   :  %2.5f",frequency/100000);
  716.  
  717.     gotoxy(1,15);
  718.     Get_Mode(r_update.r_update_data.current.mode);
  719.  
  720.     gotoxy(1,16);
  721.     Get_Filter("Filter      ",r_update.r_update_data.current.filter);
  722.  
  723.     gotoxy(1,17);
  724.     Get_Filter("Last SSB    ",r_update.r_update_data.current.ssb);
  725.  
  726.     gotoxy(1,18);
  727.     Get_Filter("Last CW     ",r_update.r_update_data.current.cw);
  728.  
  729.     gotoxy(1,19);
  730.     Get_Filter("Last RTTY   ",r_update.r_update_data.current.rtty);
  731.  
  732.     gotoxy(1,20);
  733.     Get_Filter("Last PKT    ",r_update.r_update_data.current.pkt);
  734.  
  735.     gotoxy(1,21);
  736.     printf("Skip Status :  %s\n",r_update.r_update_data.current.skip == 1 ? "True":"False");
  737.  
  738. /* VFO_A */
  739.  
  740.     gotoxy(30,13);
  741.     printf("Filter      :  %#04x",r_update.r_update_data.vfo_a.bpf);
  742.  
  743.     frequency = 0;
  744.  
  745.     frequency = frequency + ((double)r_update.r_update_data.vfo_a.freq1 * 65536);
  746.     frequency = frequency + ((double)r_update.r_update_data.vfo_a.freq2 * 256);
  747.     frequency = frequency + (double)r_update.r_update_data.vfo_a.freq3;
  748.  
  749.     gotoxy(30,14);
  750.     printf("Frequency   :  %2.5f",frequency/100000);
  751.  
  752.     gotoxy(30,15);
  753.     Get_Mode(r_update.r_update_data.vfo_a.mode);
  754.  
  755.     gotoxy(30,16);
  756.     Get_Filter("Filter      ",r_update.r_update_data.vfo_a.filter);
  757.  
  758.     gotoxy(30,17);
  759.     Get_Filter("Last SSB    ",r_update.r_update_data.vfo_a.ssb);
  760.  
  761.     gotoxy(30,18);
  762.     Get_Filter("Last CW     ",r_update.r_update_data.vfo_a.cw);
  763.  
  764.     gotoxy(30,19);
  765.     Get_Filter("Last RTTY   ",r_update.r_update_data.vfo_a.rtty);
  766.  
  767.     gotoxy(30,20);
  768.     Get_Filter("Last PKT    ",r_update.r_update_data.vfo_a.pkt);
  769.  
  770.     gotoxy(30,21);
  771.     printf("Skip Status :  %s\n",r_update.r_update_data.vfo_a.skip == 1 ? "True":"False");
  772.  
  773. /* VFO_B */
  774.  
  775.  
  776.  
  777.     gotoxy(58,13);
  778.     printf("Filter      :  %#04x",r_update.r_update_data.vfo_b.bpf);
  779.  
  780.     frequency = 0;
  781.  
  782.     frequency = frequency + ((double)r_update.r_update_data.vfo_b.freq1 * 65536);
  783.     frequency = frequency + ((double)r_update.r_update_data.vfo_b.freq2 * 256);
  784.     frequency = frequency + (double)r_update.r_update_data.vfo_b.freq3;
  785.  
  786.     gotoxy(58,14);
  787.     printf("Frequency   :  %2.5f",frequency/100000);
  788.  
  789.     gotoxy(58,15);
  790.     Get_Mode(r_update.r_update_data.vfo_b.mode);
  791.  
  792.     gotoxy(58,16);
  793.     Get_Filter("Filter      ",r_update.r_update_data.vfo_b.filter);
  794.  
  795.     gotoxy(58,17);
  796.     Get_Filter("Last SSB    ",r_update.r_update_data.vfo_b.ssb);
  797.  
  798.     gotoxy(58,18);
  799.     Get_Filter("Last CW     ",r_update.r_update_data.vfo_b.cw);
  800.  
  801.     gotoxy(58,19);
  802.     Get_Filter("Last RTTY   ",r_update.r_update_data.vfo_b.rtty);
  803.  
  804.     gotoxy(58,20);
  805.     Get_Filter("Last PKT    ",r_update.r_update_data.vfo_b.pkt);
  806.  
  807.     gotoxy(58,21);
  808.     printf("Skip Status :  %s\n",r_update.r_update_data.vfo_b.skip == 1 ? "True":"False");
  809. /********************************************************************/
  810.  
  811.     gotoxy(1,24);
  812.  
  813.  
  814.     Press_Rtn();
  815.  
  816.  
  817. }
  818.  
  819. void Tuner_Toggle(void)
  820. {
  821.     Toggle_Value(ANT_TUNER);
  822. }
  823. void Start_Tuner(void)
  824. {
  825.     send.cmd.opcode  = TUNER_START;
  826.  
  827.     Send_To_Radio();
  828.     
  829. }
  830. void Rpt_Shift_Offset(void)
  831. {
  832.     int i,j;
  833.     double offset = 0;
  834.     char freq_str[9];
  835.     char direction[2];
  836.  
  837.     send.cmd.opcode  = RPT_SHIFT;
  838. shift:
  839.     printf("Enter <ESC> to quit or '+'  '-' or '=' :  ");
  840.     gets(direction);
  841.  
  842.     switch(*direction) {
  843.           case 0x1b : return;
  844.           case '+'  : 
  845.         send.cmd.data[0] = 0x02;
  846.         break;              
  847.           case '-'  : 
  848.         send.cmd.data[0] = 0x01;
  849.         break;              
  850.           case '='  : 
  851.         send.cmd.data[0] = 0x00;
  852.         break;              
  853.           default:
  854.         goto shift;
  855.     }
  856.  
  857.     Send_To_Radio();
  858.      
  859. offset:
  860.     printf("Enter Offset Frequency : ");
  861.     scanf("%lf",&offset);    
  862.  
  863.     if(offset > 19999 ) 
  864.     {
  865.         puts("Offset must be less than 20000 khz");
  866.         goto offset;
  867.     }
  868.  
  869.     sprintf(freq_str,"%06.0f",offset);
  870.  
  871.     send.cmd.data[0]  = 0;    /* pad and set parameter (P1) */
  872.  
  873.     for(i = 0, j = 1; i < 6 ; i += 2,j++)         /* skip parameter P1 */
  874.         send.cmd.data[j] = Convert_to_BCD(&freq_str[i]);
  875.  
  876.     send.cmd.opcode  = RPT_OFFSET;
  877.  
  878.     Send_To_Radio();
  879.  
  880.  
  881. }
  882. void Vfo_A_B(void)
  883. {
  884.     send.cmd.opcode  = A_EQUAL_B;
  885.  
  886.     Send_To_Radio();
  887.     
  888. }
  889. void Bandwidth(void)
  890. {
  891.     char answer[3];    
  892.     short Bandwidth = 0;
  893.  
  894.     printf("Enter Bandwidth\n\n");
  895.     printf("\t 0.  2.4 khz\n");
  896.     printf("\t 1.  2.0 khz\n");
  897.     printf("\t 2.  500 hz\n");
  898.     printf("\t 3.  250 hz\n");
  899.     printf("\nChoice : ");
  900.     scanf("%d",&Bandwidth);
  901.     if(Bandwidth > 3) {
  902.         printf("\aMust between 0 and 3");
  903.         return;
  904.     }
  905.     send.cmd.opcode  = BANDWIDTH;
  906.     send.cmd.data[0] = BANDWIDTH;
  907.     Send_To_Radio();
  908.  
  909.     
  910. }
  911. void Mem_Scan_Skip(void)
  912. {
  913.     char ch_str[3];
  914.     char answer[2];
  915.  
  916.     short hide = 0;
  917.     short channel = 0;
  918.  
  919.     printf("Enter Channel to Change : ");
  920.     scanf("%s",ch_str);
  921.     channel = atoi(ch_str);
  922.     if((channel < 1) || (channel > 90)) {
  923.         printf("\aMust between 1 and 90");
  924.         return;
  925.     }
  926.     printf("Enter (1) to Hide or (0) to Include ");
  927.     scanf("%d",&hide);
  928.  
  929.     printf("Channel Selected : %s ",ch_str);
  930.  
  931.     if (hide)
  932.         printf("Hidden : True\n");        
  933.     else
  934.         printf("Hidden : False\n");    
  935.  
  936.     printf("okay to update (y/n) : ");
  937.     scanf("%s",answer);
  938.  
  939.     if((toupper(*answer)) == 'Y') {
  940.         send.cmd.opcode  = MEMORY_SKIP;
  941.         send.cmd.data[0] = channel;
  942.         send.cmd.data[1] = hide;
  943.  
  944.         Send_To_Radio();
  945.     }
  946.         
  947. }
  948. int Step_Freq(void)
  949. {
  950.     unsigned char c;
  951.     int counter = 0;
  952.  
  953.     clrscr();
  954.  
  955.     puts("Enter <ESC> to quit or '+' or '-'");
  956.  
  957.     for(;;) {
  958.      if(kbhit()) {
  959.         gotoxy(35,12);
  960.        switch(getch()) {
  961.           case 0x1b : 
  962.         clrscr();
  963.         return(counter);
  964.           case '+'  : 
  965.         puts("UP  ");
  966.         send.cmd.opcode  = STEP_FREQ;
  967.         send.cmd.data[0]  = 0;
  968.         counter++;
  969.         break;              
  970.           case '-'  : 
  971.         puts("DOWN");
  972.         send.cmd.opcode  = STEP_FREQ;
  973.         send.cmd.data[0]  = 1;
  974.         counter--;
  975.         break;              
  976.        }
  977.        Send_To_Radio();
  978.      }
  979.         }
  980.  
  981.  
  982. }
  983. void Read_Meter(void)
  984. {
  985.     clrscr();
  986.     puts("Presently under beta test for FT-990");
  987.  
  988.     send.cmd.opcode  = READ_METER;
  989.  
  990.     Send_To_Radio();
  991.     
  992.     Read_5_Bytes();
  993.  
  994.     printf("Meter value is : (%d)\n",rcv_cmd.r_meter.meter1);
  995.  
  996.     if (rcv_cmd.r_meter.meter1 == 0)
  997.         printf("S-Meter reading is S0");
  998.     if (rcv_cmd.r_meter.meter1 > 1 && rcv_cmd.r_meter.meter1 < 10 )
  999.         printf("S-Meter reading is S1");
  1000.     if (rcv_cmd.r_meter.meter1 > 10 && rcv_cmd.r_meter.meter1 < 41)
  1001.         printf("S-Meter reading is S3");
  1002.     if (rcv_cmd.r_meter.meter1 > 40 && rcv_cmd.r_meter.meter1 < 71)
  1003.         printf("S-Meter reading is S5");
  1004.     if (rcv_cmd.r_meter.meter1 > 70 && rcv_cmd.r_meter.meter1 < 101)
  1005.         printf("S-Meter reading is S7");
  1006.     if (rcv_cmd.r_meter.meter1 > 100 && rcv_cmd.r_meter.meter1 < 126)
  1007.         printf("S-Meter reading is S9");
  1008.     if (rcv_cmd.r_meter.meter1 > 125 && rcv_cmd.r_meter.meter1 < 146)
  1009.         printf("S-Meter reading is S9 + 10");
  1010.     if (rcv_cmd.r_meter.meter1 > 145 && rcv_cmd.r_meter.meter1 < 166)
  1011.         printf("S-Meter reading is S9 + 20");
  1012.     if (rcv_cmd.r_meter.meter1 > 165 && rcv_cmd.r_meter.meter1 < 186)
  1013.         printf("S-Meter reading is S9 + 30");
  1014.     if (rcv_cmd.r_meter.meter1 > 185 && rcv_cmd.r_meter.meter1 < 206)
  1015.         printf("S-Meter reading is S9 + 40");
  1016.     if (rcv_cmd.r_meter.meter1 > 205 && rcv_cmd.r_meter.meter1 < 231)
  1017.         printf("S-Meter reading is S9 + 50");
  1018.     if (rcv_cmd.r_meter.meter1 > 230 && rcv_cmd.r_meter.meter1 < 251)
  1019.         printf("S-Meter reading is S9 + 50");
  1020.  
  1021.  
  1022.     Press_Rtn();    
  1023.     
  1024. }
  1025. void Dim_Level(void)
  1026. {
  1027.     unsigned short i = 0;
  1028.     printf("Press any key to toggle <ESC> to exit\n ");
  1029.     for(;;) {
  1030.      if(kbhit()) {
  1031.        if((getch()) == 0x1b)
  1032.            break;
  1033.        else {
  1034.         if (i > 0x0d)
  1035.             i = 0;
  1036.            gotoxy(30,12);
  1037.            printf("Dim Value (%-2d)",i);
  1038.         send.cmd.data[0] = i++;
  1039.        }
  1040.            send.cmd.opcode  = DIM_LEVEL;
  1041.        Send_To_Radio();
  1042.      }
  1043.     }
  1044.     
  1045. }
  1046. void Read_Flags(void)
  1047. {
  1048.     clrscr();
  1049.  
  1050.     send.cmd.opcode  = READ_FLAGS;
  1051.  
  1052.     Send_To_Radio();
  1053.     
  1054.     Read_5_Bytes();
  1055.  
  1056. /********Rig type *********/
  1057.     printf("                       Model : ");
  1058.  
  1059.     switch(rcv_cmd.r_flags.rig1)
  1060.     {
  1061.       case 0x10  :    printf("FT-1000\n");     break;
  1062.       case 0x09  :    printf("FT-990\n");    break;
  1063.       case 0x08  :    printf("FT-890\n");    break;
  1064.       default    :    printf("\n");        break;
  1065.     }
  1066.  
  1067.     puts("                       ==============");
  1068.  
  1069. /********Byte 1 ***********/
  1070.  
  1071.     printf("Split       : %s\n",rcv_cmd.r_flags.byte_1.bit_0 == 0 ? "Off":"On");
  1072.     printf("VFO_B       : %s\n",rcv_cmd.r_flags.byte_1.bit_1 == 0 ? "Transmit" : "Receive");
  1073.     printf("Fast Tuning : %s\n",rcv_cmd.r_flags.byte_1.bit_2 == 0 ? "Off" : "On");
  1074.     printf("CAT         : %s\n",rcv_cmd.r_flags.byte_1.bit_3 == 0 ? "Off" : "On");
  1075.     printf("Tuner       : %s\n",rcv_cmd.r_flags.byte_1.bit_4 == 0 ? "Inactive" : "Tuning");
  1076.     printf("Keyboard    : %s\n",rcv_cmd.r_flags.byte_1.bit_5 == 0 ? "Idle" : "In-progress");
  1077.     printf("Current Mem : %s\n",rcv_cmd.r_flags.byte_1.bit_6 == 0 ? "Not Blank" : "Empty");
  1078.     printf("Transmision : %s\n",rcv_cmd.r_flags.byte_1.bit_7 == 0 ? "None" : "In-progress");
  1079.  
  1080. /********Byte 2 ***********/
  1081.  
  1082.     printf("Scan Paused : %s\n",rcv_cmd.r_flags.byte_2.bit_0 == 0 ? "False" : "True");
  1083.     printf("Memory CHK  : %s\n",rcv_cmd.r_flags.byte_2.bit_1 == 0 ? "Off" : "In-progress");
  1084.     printf("Scanning    : %s\n",rcv_cmd.r_flags.byte_2.bit_2 == 0 ? "None" : "In-progress");
  1085.     printf("Tuning Knob : %s\n",rcv_cmd.r_flags.byte_2.bit_3 == 0 ? "Unlocked" : "Locked");
  1086.     printf("M Tune      : %s\n",rcv_cmd.r_flags.byte_2.bit_4 == 0 ? "Inactive" : "Active");
  1087.  
  1088.     printf("Operation   : ");
  1089.  
  1090.     if(rcv_cmd.r_flags.byte_2.bit_5 == TRUE)
  1091.         printf(" VFO ");
  1092.     else if(rcv_cmd.r_flags.byte_2.bit_6 == TRUE)
  1093.         printf(" MEM ");
  1094.     else if(rcv_cmd.r_flags.byte_2.bit_7 == TRUE)
  1095.         printf(" GEN ");
  1096.  
  1097.     printf("\n");
  1098.  
  1099. /********Byte 3 ***********/
  1100.  
  1101.     printf("PTT by CAT  : %s\n",rcv_cmd.r_flags.byte_3.bit_0 == 0 ? "False" : "True");
  1102.     printf("TX inhibit  : %s\n",rcv_cmd.r_flags.byte_3.bit_1 == 0 ? "Off" : "On");
  1103.     printf("Key Timer   : %s\n",rcv_cmd.r_flags.byte_3.bit_2 == 0 ? "Off" : "On");
  1104.     printf("M CHK Timer : %s\n",rcv_cmd.r_flags.byte_3.bit_3 == 0 ? "Off" : "On");
  1105.     printf("PTT Inhibit : %s\n",rcv_cmd.r_flags.byte_3.bit_4 == 0 ? "Off" : "On");
  1106.     printf("TX Monitor  : %s\n",rcv_cmd.r_flags.byte_3.bit_5 == 0 ? "Off" : "On");
  1107.     printf("Tuner       : %s\n",rcv_cmd.r_flags.byte_3.bit_6 == 0 ? "Off" : "On");
  1108.     printf("Spot        : %s",rcv_cmd.r_flags.byte_3.bit_7 == 0 ? "Off" : "On");
  1109.  
  1110.     Press_Rtn();    
  1111.     
  1112. }
  1113. void Press_Rtn(void)
  1114. {
  1115.     printf("\n                         Press any key to Continue"); 
  1116.     while(!kbhit());
  1117.     getch();
  1118. }
  1119. void Read_5_Bytes(void)
  1120. {
  1121.     short i = 0;
  1122.     
  1123.     delay(500); 
  1124.  
  1125. /*    printf("Characters read : %d\n",rs_inrcvd()); */
  1126.  
  1127.     while(rs_inrcvd()) {
  1128.        if (i < 5)
  1129.         rcv_cmd.rcv_data.fill[i++] = rs_getbyt();
  1130.       else
  1131.               rs_getbyt();
  1132.     }
  1133. }
  1134. void Read_Status(void)
  1135. {
  1136.     unsigned int i = 0;
  1137.     
  1138.     printf("Stand-by retrieving information....");
  1139.  
  1140.     delay(4000);
  1141.  
  1142.     clrscr();
  1143.  
  1144. /*    printf("Characters Recvd : %d\n",rs_inrcvd()); */
  1145.  
  1146.     while(rs_inrcvd()) {
  1147.        if (i < UPDATE_DATA_SIZE)
  1148.         r_update.r_update_fill.fill[i++] = rs_getbyt();
  1149.       else
  1150.               rs_getbyt();
  1151.  
  1152.     }
  1153. }
  1154. void Update_Radio()
  1155. {
  1156. FILE *in;
  1157.  
  1158.     int    i,
  1159.         j, 
  1160.         channel,
  1161.         mode;
  1162.     
  1163.     double real_freq = 0;
  1164.     double freq_khz = 0;
  1165.  
  1166.     char freq_out[20];
  1167.     char freq_str[20];
  1168.     char comments[80];
  1169.     char tmp[10];
  1170.  
  1171.     if((in = fopen("MYCONFIG.DAT","r")) == NULL){
  1172.         perror("Error Opening MYCONFIG");
  1173.         Press_Rtn();
  1174.         return;
  1175.     }
  1176.  
  1177. /* put radio into vfo mode */
  1178.  
  1179.     send.cmd.opcode  = SELECT_VFO;
  1180.     Send_To_Radio();
  1181.  
  1182.     while( (fscanf(in,"%d %lf %d %s",&channel,&real_freq,&mode,comments)) !=EOF){
  1183.  
  1184. /* set mode */
  1185.  
  1186.      switch(mode){
  1187.        case 0 :     strcpy(tmp,"LSB");
  1188.             break;
  1189.        case 1 :    strcpy(tmp,"USB");
  1190.             break;
  1191.        case 2 :    strcpy(tmp,"CW 2.4K");
  1192.             break;
  1193.        case 3 :    strcpy(tmp,"CW 500");
  1194.             break;
  1195.        case 4 :    strcpy(tmp,"AM 6K");
  1196.             break;
  1197.        case 5 :    strcpy(tmp,"AM 2.4K");
  1198.             break;
  1199.        case 6 :
  1200.        case 7 :    strcpy(tmp,"FM");
  1201.             break;
  1202.        case 8 :    strcpy(tmp,"RTTY LSB");
  1203.             break;
  1204.        case 9 :    strcpy(tmp,"RTTY USB");
  1205.             break;
  1206.        case 10:     strcpy(tmp,"PKT LSB");
  1207.             break;
  1208.        case 11:    strcpy(tmp,"PKT FM");
  1209.             break;
  1210.        default:    printf("\amode (%d) illegal on Channel entry %d\n",mode,channel);
  1211.             Press_Rtn();
  1212.             return;
  1213.      }
  1214.  
  1215.      send.cmd.opcode  = SET_MODE;
  1216.      send.cmd.data[0] = mode;
  1217.      Send_To_Radio();
  1218.  
  1219. /* Calculate frequency */
  1220.  
  1221.      freq_khz = real_freq * 100000.0;
  1222.  
  1223.      if ((freq_khz > 2999999) || (freq_khz < 100)){
  1224.         printf("(%lf) out of range -- re-enter\n\a",freq_khz);
  1225.         Press_Rtn();
  1226.         return;
  1227.      }
  1228.  
  1229.      sprintf(freq_str,"%08.0f",freq_khz);
  1230.  
  1231.      send.cmd.opcode = SET_FREQ;        
  1232.  
  1233.      for(i = 0, j = 0; i < 8 ; i += 2,j++)    
  1234.       send.cmd.data[j] = Convert_to_BCD(&freq_str[i]);
  1235.  
  1236. /* display update info */
  1237.  
  1238.      printf("Ch : %2d  Freq : %10.5f  Mode : %-8s Desc : %s\n",channel,real_freq,tmp,comments);
  1239.  
  1240. /* update radio's frequency */
  1241.  
  1242.      Send_To_Radio();
  1243.  
  1244. /* store in defined memory */
  1245.  
  1246.      if(channel > 90){
  1247.         printf("\a---> chan (%d) illegal\n",channel);
  1248.         Press_Rtn();
  1249.         return;
  1250.      }
  1251.  
  1252.      send.cmd.opcode  = VFO_M;
  1253.      send.cmd.data[0] = channel;
  1254.      Send_To_Radio();
  1255.  
  1256.         }
  1257.  
  1258.     Press_Rtn();
  1259.         fclose(in);
  1260.  
  1261. }
  1262. void Flush_Inbuffer(void)
  1263. {
  1264.     while(rs_inrcvd())
  1265.         rs_getbyt(); 
  1266. }
  1267. void Scan_File(void)
  1268. {
  1269. FILE *in;
  1270.  
  1271.     int    c= 0,
  1272.         i= 0,
  1273.         j= 0, 
  1274.         l= 0,
  1275.         m= 0,
  1276.         time_delay = 0,    
  1277.         mode[255];
  1278.  
  1279.     int loop =0;
  1280.     double real_freq[255];
  1281.     double freq_khz[255];
  1282.  
  1283.     char freq_out[20];
  1284.     char freq_str[20];
  1285.     char tmp[10];
  1286.     char comments[255][80];
  1287.     char filename[64];
  1288.  
  1289.     printf("Files available for scanning\n");
  1290.     printf("----------------------------\n");
  1291.  
  1292.     ScanDir();
  1293.  
  1294.     printf("\n\nEnter Filename : ");
  1295.     gets(filename);
  1296.  
  1297.     if (*filename == '\0')
  1298.         return;
  1299.  
  1300.     if((in = fopen(filename,"rb")) == NULL){
  1301.         perror("Error Opening specified file");
  1302.         Press_Rtn();
  1303.         return;
  1304.     }
  1305.  
  1306.     printf("Enter scan delay in Seconds : ");
  1307.     scanf("%d",&time_delay);
  1308.     time_delay *=  1000;
  1309.  
  1310. /* put radio into vfo mode */
  1311.  
  1312.     send.cmd.opcode  = SELECT_VFO;
  1313.     Send_To_Radio();
  1314.  
  1315.     while( (fscanf(in,"%lf %d %s",&real_freq[i],&mode[i],comments[i])) !=EOF)
  1316.     {
  1317.         if (i > 255){
  1318.            puts("file has to many entries -- must be less than 256");
  1319.            Press_Rtn();
  1320.            return;
  1321.         }
  1322.         i++;
  1323.     }
  1324.  
  1325.     for(j = 0 ; j < i ; j++)
  1326.         freq_khz[j] = real_freq[j] * 100000.0;
  1327.     
  1328. /* start scanning */
  1329.  
  1330.     clrscr();
  1331.  
  1332.     gotoxy(20,20);
  1333.  
  1334.     puts("Press any key to stop scanning");
  1335.  
  1336.     for(loop = 0 ; loop < j ; loop++){    
  1337.  
  1338.      send.cmd.opcode  = SET_MODE;
  1339.      send.cmd.data[0] = mode[loop];
  1340.      Send_To_Radio();
  1341.  
  1342. /* Calculate frequency */
  1343.  
  1344.      sprintf(freq_str,"%08.0f",freq_khz[loop]);
  1345.  
  1346.      send.cmd.opcode = SET_FREQ;        
  1347.  
  1348.      for(l = 0, m = 0; l < 8 ; l += 2,m++)    
  1349.       send.cmd.data[m] = Convert_to_BCD(&freq_str[l]);
  1350.  
  1351. /* update radio's frequency */
  1352.  
  1353.      gotoxy(20,13);    
  1354.      clreol();
  1355.      printf("Freq %lf  Desc : %s\n",real_freq[loop],comments[loop]);
  1356.  
  1357.      Send_To_Radio();
  1358.  
  1359.      if(loop == j - 1)
  1360.       loop= -1;        /* reset and start over */
  1361.  
  1362.      delay(time_delay);
  1363.  
  1364.      if (kbhit()){
  1365.         gotoxy(20,20);
  1366.         clreol();
  1367.         printf("Press any key to continue scan or <ESC> to exit");
  1368.         c = getch();
  1369.         if (c == ESC)
  1370.             break;
  1371.  
  1372.          while (!kbhit());
  1373.         c = getch();
  1374.         if (c == ESC)
  1375.             break;
  1376.  
  1377.         gotoxy(20,20);
  1378.         clreol();
  1379.      }
  1380.  
  1381.         }
  1382.  
  1383.         fclose(in);
  1384. }
  1385.  
  1386. void Toggle_Value(command)
  1387. {
  1388.     short flag = 0;
  1389.     printf("Press any key to toggle <ESC> to exit\n ");
  1390.     for(;;) {
  1391.      if(kbhit()) {
  1392.        if((getch()) == 0x1b)
  1393.            break;
  1394.        else {
  1395.         gotoxy(35,12);
  1396.         if( flag){
  1397.             puts("OFF");
  1398.             send.cmd.data[0] = OFF;
  1399.             flag = FALSE;
  1400.         }
  1401.         else{
  1402.             puts("ON "); 
  1403.             send.cmd.data[0] = ON;
  1404.             flag = TRUE;
  1405.         }
  1406.                 send.cmd.opcode  = command;
  1407.         Send_To_Radio();
  1408.        }
  1409.      }
  1410.     }
  1411. }
  1412. void ScanDir(void)
  1413. {
  1414.     struct ffblk ffblk;
  1415.  
  1416.     int done=0;
  1417.  
  1418.     done = findfirst("*.dat",&ffblk,0);
  1419.  
  1420.     while(!done)
  1421.     {
  1422.           if(strstr(ffblk.ff_name,"MYCONFIG.DAT") == NULL) 
  1423.             printf("%s\n",ffblk.ff_name);
  1424.           done = findnext(&ffblk);
  1425.  
  1426.     }          
  1427.  
  1428. }
  1429.     
  1430. void Get_Mode(tmp)
  1431. {
  1432.     switch(tmp)
  1433.     {
  1434.         case 0 : printf("Mode        :  LSB");break;
  1435.         case 1 : printf("Mode        :  USB");break;
  1436.         case 2 : printf("Mode        :  CW");break;
  1437.         case 3 : printf("Mode        :  AM");break;
  1438.         case 4 : printf("Mode        :  FM");break;
  1439.         case 5 : printf("Mode        :  RTTY");break;
  1440.         case 6 : printf("Mode        :  PKT");break;
  1441.     }
  1442.  
  1443. }
  1444.  
  1445. void Get_Filter(char *desc,int tmp)
  1446. {
  1447.     switch(tmp)
  1448.     {
  1449.         case 0 : printf("%12s:  2.4k",desc);break;
  1450.         case 1 : printf("%12s:  2.0k",desc);break;
  1451.         case 2 : printf("%12s:  500",desc);break;
  1452.         case 3 : printf("%12s:  250",desc);break;
  1453.         case 4 : printf("%12s:  6k",desc);break;
  1454.         default: printf("%12s:  UNKNOWN",desc);break;
  1455.     }
  1456. }
  1457. void Disp_Mem(void)
  1458. {
  1459.  
  1460. #define    MEM_OFFSET    36    /* starting position of VFO_B */
  1461.  
  1462. /*    struct BYTE_16 memory_channel; */
  1463.  
  1464.     struct BYTE_16 *memptr;
  1465.  
  1466.     int offset = 0;
  1467.     int channel = 0;
  1468.  
  1469.     double frequency = 0;
  1470.  
  1471.     clrscr();
  1472.  
  1473. channel:
  1474.     printf("Enter Memory Channel to review : ");
  1475.     scanf("%d",&channel);
  1476.  
  1477.     if ( (channel == 0) || (channel > 90) )
  1478.     {
  1479.         printf("out-of-range\n");
  1480.         sleep(2);    
  1481.         goto channel;
  1482.     }
  1483.  
  1484.     send.cmd.opcode  = UPDATE;
  1485.  
  1486.     Send_To_Radio();
  1487.     
  1488.     Read_Status();
  1489.  
  1490.     clrscr();
  1491.  
  1492.     offset = MEM_OFFSET + (channel  * 16); 
  1493.     
  1494. /*    memcpy(&memory_channel , &r_update.r_update_fill.fill[offset] , 16); */
  1495.  
  1496.     memptr = (struct BYTE_16 *)&r_update.r_update_fill.fill[offset];
  1497.  
  1498.     gotoxy(25,3);
  1499.  
  1500.     printf("Memory Channel  :  ( %d ) \n",channel);
  1501.  
  1502. /********************************************************************/
  1503.  
  1504.     gotoxy(28,5);
  1505.     printf("  Current status\n");
  1506.  
  1507.     gotoxy(28,6);
  1508.     printf("  --------------\n");
  1509.  
  1510.     gotoxy(28,8);
  1511.     printf("Filter      :  %#04x\r\n",memptr->bpf);
  1512.  
  1513.  
  1514.     frequency = frequency + ((double)memptr->freq1 * 65536);
  1515.     frequency = frequency + ((double)memptr->freq2 * 256);
  1516.     frequency = frequency + (double)memptr->freq3;
  1517.  
  1518.     gotoxy(28,9);
  1519.     printf("Frequency   :  %2.5f\r\n",frequency/100000);
  1520.  
  1521.     gotoxy(28,10);
  1522.     Get_Mode(memptr->mode);
  1523.  
  1524.     gotoxy(28,11);
  1525.     Get_Filter("Filter      ",memptr->filter);
  1526.  
  1527.     gotoxy(28,12);
  1528.     Get_Filter("Last SSB    ",memptr->ssb);
  1529.  
  1530.     gotoxy(28,13);
  1531.     Get_Filter("Last CW     ",memptr->cw);
  1532.  
  1533.     gotoxy(28,14);
  1534.     Get_Filter("Last RTTY   ",memptr->rtty);
  1535.  
  1536.     gotoxy(28,15);
  1537.     Get_Filter("Last PKT    ",memptr->pkt);
  1538.  
  1539.     gotoxy(28,16);
  1540.     printf("Skip Status :  %s\r\n",memptr->skip == 1 ? "True":"False");
  1541.  
  1542.     gotoxy(1,24);
  1543.  
  1544.  
  1545.     Press_Rtn();
  1546.  
  1547. }